/**
 * 路由保护机制
 * 处理页面访问权限控制和认证状态检查
 */
class RouteGuard {
    constructor() {
        this.publicRoutes = [
            '/index.html',
            '/home.html',
            '/', 
            '/health',
            '/favicon.ico'
        ];
        
        this.authRequiredRoutes = [
            '/dashboard.html',
            '/profile.html',
            '/features.html'
        ];
        
        this.init();
    }

    init() {
        // 页面加载时检查路由权限
        this.checkCurrentRoute();
        
        // 监听页面变化
        this.setupRouteListeners();
        
        // 监听认证状态变化
        this.setupAuthListeners();
    }

    /**
     * 检查当前路由权限
     */
    checkCurrentRoute() {
        const currentPath = window.location.pathname;
        
        // 检查是否需要认证
        if (this.requiresAuth(currentPath)) {
            this.protectRoute(currentPath);
        } else {
            this.handlePublicRoute(currentPath);
        }
    }

    /**
     * 检查路由是否需要认证
     */
    requiresAuth(path) {
        return this.authRequiredRoutes.some(route => 
            path === route || path.startsWith(route + '?')
        );
    }

    /**
     * 检查是否为公共路由
     */
    isPublicRoute(path) {
        return this.publicRoutes.some(route => 
            path === route || path.startsWith(route + '?')
        );
    }

    /**
     * 保护需要认证的路由
     */
    protectRoute(path) {
        if (!window.authManager) {
            console.warn('认证管理器未加载，跳转到登录页面');
            this.redirectToLogin(path);
            return;
        }

        const isLoggedIn = window.authManager.isLoggedIn();
        
        if (!isLoggedIn) {
            console.log('用户未登录，跳转到登录页面');
            this.redirectToLogin(path);
            return;
        }

        // 检查Token是否即将过期
        if (window.authManager.isTokenExpiringSoon(30)) {
            console.log('Token即将过期，尝试刷新');
            window.authManager.refreshToken();
        }

        console.log('用户已认证，允许访问:', path);
        this.setupRouteProtection(path);
    }

    /**
     * 处理公共路由
     */
    handlePublicRoute(path) {
        console.log('访问公共路由:', path);
        
        // 如果是登录页面且用户已登录，可以重定向到首页
        if ((path === '/index.html' || path === '/') && window.authManager && window.authManager.isLoggedIn()) {
            const urlParams = new URLSearchParams(window.location.search);
            const redirect = urlParams.get('redirect');
            const flag = urlParams.get('flag');
            
            // 检查是否有flag参数，如果有则不进行自动重定向
            if (flag) {
                console.log('检测到flag参数（', flag, '），不进行自动重定向');
                return;
            }
            
            if (redirect) {
                console.log('已登录用户访问登录页面，重定向到:', redirect);
                window.location.href = decodeURIComponent(redirect);
            } else {
                // 获取用户信息，构建跳转到首页的URL
                const userInfo = window.authManager.getUserInfo();
                let homeUrl = 'home.html';
                
                if (userInfo && userInfo.buserid) {
                    homeUrl += `?buserid=${userInfo.buserid}`;
                    if (userInfo.muserid) {
                        homeUrl += `&muserid=${userInfo.muserid}`;
                    }
                    if (userInfo.flag) {
                        homeUrl += `&flag=${userInfo.flag}`;
                    }
                }
                
                console.log('已登录用户访问登录页面，重定向到首页:', homeUrl);
                window.location.href = homeUrl;
            }
        }
    }

    /**
     * 跳转到登录页面
     */
    redirectToLogin(currentPath = null) {
        let loginUrl = 'index.html';
        
        // 保存当前页面URL，登录后跳转回来
        if (currentPath && currentPath !== '/index.html' && currentPath !== '/') {
            const returnUrl = encodeURIComponent(window.location.href);
            loginUrl += `?redirect=${returnUrl}`;
        }
        
        console.log('重定向到登录页面:', loginUrl);
        window.location.href = loginUrl;
    }

    /**
     * 设置路由保护
     */
    setupRouteProtection(path) {
        // 为页面添加认证状态标记
        this.addAuthStatusIndicator();
        
        // 设置页面离开时的认证检查
        this.setupBeforeUnloadHandler();
        
        // 定期检查认证状态
        this.setupAuthCheckInterval();
    }

    /**
     * 添加认证状态指示器
     */
    addAuthStatusIndicator() {
        // 在页面中显示认证状态（调试用）
        if (window.authManager && window.authManager.isLoggedIn()) {
            const userInfo = window.authManager.getUserInfo();
            const timeRemaining = window.authManager.getTokenTimeRemaining();
            
            console.log(`✅ 已认证用户: ${userInfo.name || '未知用户'}`);
            console.log(`🔑 Token有效期: ${timeRemaining}分钟`);
            
            // 可以在页面上添加状态指示器
            this.addStatusBadge('authenticated', `已登录 (${timeRemaining}分钟)`);
        }
    }

    /**
     * 添加状态徽章
     */
    addStatusBadge(type, message) {
        // 移除现有的状态徽章
        const existingBadge = document.getElementById('auth-status-badge');
        if (existingBadge) {
            existingBadge.remove();
        }
        
        // 创建新的状态徽章
        const badge = document.createElement('div');
        badge.id = 'auth-status-badge';
        badge.style.cssText = `
            position: fixed;
            top: 10px;
            right: 10px;
            background: ${type === 'authenticated' ? '#28a745' : '#dc3545'};
            color: white;
            padding: 5px 10px;
            border-radius: 15px;
            font-size: 12px;
            z-index: 9999;
            font-family: monospace;
            box-shadow: 0 2px 4px rgba(0,0,0,0.2);
        `;
        badge.textContent = message;
        
        document.body.appendChild(badge);
        
        // 3秒后自动移除
        setTimeout(() => {
            if (badge.parentNode) {
                badge.remove();
            }
        }, 3000);
    }

    /**
     * 设置页面离开前的处理器
     */
    setupBeforeUnloadHandler() {
        window.addEventListener('beforeunload', (event) => {
            if (window.authManager && window.authManager.isLoggedIn()) {
                // 可以在这里添加离开页面的逻辑
                // 例如：保存状态、发送统计数据等
            }
        });
    }

    /**
     * 设置定期认证检查
     */
    setupAuthCheckInterval() {
        // 每5分钟检查一次认证状态
        setInterval(() => {
            if (window.authManager) {
                const isLoggedIn = window.authManager.isLoggedIn();
                const timeRemaining = window.authManager.getTokenTimeRemaining();
                
                if (!isLoggedIn) {
                    console.warn('认证状态失效，即将跳转到登录页面');
                    this.addStatusBadge('error', '认证失效，请重新登录');
                    
                    // 延迟跳转，让用户看到提示
                    setTimeout(() => {
                        this.redirectToLogin();
                    }, 2000);
                } else if (timeRemaining < 10) {
                    console.warn('Token即将过期，尝试刷新');
                    this.addStatusBadge('warning', 'Token即将过期');
                    
                    window.authManager.refreshToken().then(success => {
                        if (success) {
                            this.addStatusBadge('success', 'Token已刷新');
                        } else {
                            this.addStatusBadge('error', 'Token刷新失败');
                        }
                    });
                }
            }
        }, 5 * 60 * 1000); // 5分钟
    }

    /**
     * 设置路由监听器
     */
    setupRouteListeners() {
        // 监听浏览器前进/后退
        window.addEventListener('popstate', () => {
            this.checkCurrentRoute();
        });

        // 拦截所有链接点击
        document.addEventListener('click', (event) => {
            const link = event.target.closest('a');
            if (link && link.href) {
                const href = link.href;
                
                // 检查是否是内部链接
                if (this.isInternalLink(href)) {
                    const url = new URL(href);
                    const path = url.pathname;
                    
                    // 如果是需要认证的链接且用户未登录，阻止跳转
                    if (this.requiresAuth(path) && 
                        (!window.authManager || !window.authManager.isLoggedIn())) {
                        event.preventDefault();
                        this.redirectToLogin(path);
                        return;
                    }
                }
            }
        });
    }

    /**
     * 检查是否为内部链接
     */
    isInternalLink(href) {
        try {
            const url = new URL(href);
            return url.hostname === window.location.hostname;
        } catch {
            return false;
        }
    }

    /**
     * 设置认证监听器
     */
    setupAuthListeners() {
        if (window.authManager) {
            // 监听登录事件
            window.authManager.onAuthChange('login', (userData) => {
                console.log('用户登录成功，更新路由状态');
                this.addStatusBadge('authenticated', `欢迎回来，${userData.name || '用户'}`);
                
                // 处理登录后的重定向
                this.handleLoginRedirect();
            });

            // 监听登出事件
            window.authManager.onAuthChange('logout', () => {
                console.log('用户已登出，清理路由状态');
                this.addStatusBadge('error', '已退出登录');
                
                // 如果当前是需要认证的页面，跳转到登录页
                const currentPath = window.location.pathname;
                if (this.requiresAuth(currentPath)) {
                    setTimeout(() => {
                        this.redirectToLogin();
                    }, 1000);
                }
            });
        }
    }

    /**
     * 处理登录后的重定向
     */
    handleLoginRedirect() {
        const urlParams = new URLSearchParams(window.location.search);
        const redirect = urlParams.get('redirect');
        
        if (redirect) {
            // 清理URL参数中的redirect
            const cleanUrl = window.location.pathname + window.location.search.replace(/[?&]redirect=[^&]*/, '');
            window.history.replaceState({}, document.title, cleanUrl);
            
            // 延迟跳转，让用户看到登录成功的提示
            setTimeout(() => {
                window.location.href = decodeURIComponent(redirect);
            }, 1000);
        }
    }

    /**
     * 手动触发路由检查
     */
    checkRoute() {
        this.checkCurrentRoute();
    }

    /**
     * 获取当前路由信息
     */
    getCurrentRouteInfo() {
        const path = window.location.pathname;
        const search = window.location.search;
        const hash = window.location.hash;
        
        return {
            path,
            search,
            hash,
            fullPath: path + search + hash,
            requiresAuth: this.requiresAuth(path),
            isPublic: this.isPublicRoute(path),
            timestamp: Date.now()
        };
    }

    /**
     * 添加新的公共路由
     */
    addPublicRoute(route) {
        if (!this.publicRoutes.includes(route)) {
            this.publicRoutes.push(route);
        }
    }

    /**
     * 添加需要认证的路由
     */
    addAuthRequiredRoute(route) {
        if (!this.authRequiredRoutes.includes(route)) {
            this.authRequiredRoutes.push(route);
        }
    }

    /**
     * 移除路由配置
     */
    removeRoute(route) {
        this.publicRoutes = this.publicRoutes.filter(r => r !== route);
        this.authRequiredRoutes = this.authRequiredRoutes.filter(r => r !== route);
    }
}

// 页面加载时初始化路由保护
document.addEventListener('DOMContentLoaded', () => {
    // 等待认证管理器加载完成
    setTimeout(() => {
        window.routeGuard = new RouteGuard();
    }, 100);
});

// 导出类（供模块化使用）
if (typeof module !== 'undefined' && module.exports) {
    module.exports = RouteGuard;
}